import {
  CubeUVReflectionMapping,
  GammaEncoding,
  LinearEncoding,
  NoToneMapping,
  NearestFilter,
  NoBlending,
  RGBDEncoding,
  RGBEEncoding,
  RGBEFormat,
  RGBM16Encoding,
  RGBM7Encoding,
  UnsignedByteType,
  sRGBEncoding,
} from '../constants.js'

import {BufferAttribute} from '../core/BufferAttribute.js'
import {BufferGeometry} from '../core/BufferGeometry.js'
import {Mesh} from '../objects/Mesh.js'
import {OrthographicCamera} from '../cameras/OrthographicCamera.js'
import {PerspectiveCamera} from '../cameras/PerspectiveCamera.js'
import {RawShaderMaterial} from '../materials/RawShaderMaterial.js'
import {Vector2} from '../math/Vector2.js'
import {Vector3} from '../math/Vector3.js'
import {WebGLRenderTarget} from '../renderers/WebGLRenderTarget.js'

const LOD_MIN = 4
const LOD_MAX = 8
const SIZE_MAX = Math.pow(2, LOD_MAX)

// The standard deviations (radians) associated with the extra mips. These are
// chosen to approximate a Trowbridge-Reitz distribution function times the
// geometric shadowing function. These sigma values squared must match the
// variance #defines in cube_uv_reflection_fragment.glsl.js.
const EXTRA_LOD_SIGMA = [0.125, 0.215, 0.35, 0.446, 0.526, 0.582]

const TOTAL_LODS = LOD_MAX - LOD_MIN + 1 + EXTRA_LOD_SIGMA.length

// The maximum length of the blur for loop. Smaller sigmas will use fewer
// samples and exit early, but not recompile the shader.
const MAX_SAMPLES = 20

const ENCODINGS = {
  [LinearEncoding]: 0,
  [sRGBEncoding]: 1,
  [RGBEEncoding]: 2,
  [RGBM7Encoding]: 3,
  [RGBM16Encoding]: 4,
  [RGBDEncoding]: 5,
  [GammaEncoding]: 6,
}

const _flatCamera = /*@__PURE__*/ new OrthographicCamera()
const {_lodPlanes, _sizeLods, _sigmas} = /*@__PURE__*/ _createPlanes()
let _oldTarget = null

// Golden Ratio
const PHI = (1 + Math.sqrt(5)) / 2
const INV_PHI = 1 / PHI

// Vertices of a dodecahedron (except the opposites, which represent the
// same axis), used as axis directions evenly spread on a sphere.
const _axisDirections = [
  /*@__PURE__*/ new Vector3(1, 1, 1),
  /*@__PURE__*/ new Vector3(-1, 1, 1),
  /*@__PURE__*/ new Vector3(1, 1, -1),
  /*@__PURE__*/ new Vector3(-1, 1, -1),
  /*@__PURE__*/ new Vector3(0, PHI, INV_PHI),
  /*@__PURE__*/ new Vector3(0, PHI, -INV_PHI),
  /*@__PURE__*/ new Vector3(INV_PHI, 0, PHI),
  /*@__PURE__*/ new Vector3(-INV_PHI, 0, PHI),
  /*@__PURE__*/ new Vector3(PHI, INV_PHI, 0),
  /*@__PURE__*/ new Vector3(-PHI, INV_PHI, 0),
]

/**
 * This class generates a Prefiltered, Mipmapped Radiance Environment Map
 * (PMREM) from a cubeMap environment texture. This allows different levels of
 * blur to be quickly accessed based on material roughness. It is packed into a
 * special CubeUV format that allows us to perform custom interpolation so that
 * we can support nonlinear formats such as RGBE. Unlike a traditional mipmap
 * chain, it only goes down to the LOD_MIN level (above), and then creates extra
 * even more filtered 'mips' at the same LOD_MIN resolution, associated with
 * higher roughness levels. In this way we maintain resolution to smoothly
 * interpolate diffuse lighting while limiting sampling computation.
 */

class PMREMGenerator {
  constructor(renderer) {
    this._renderer = renderer
    this._pingPongRenderTarget = null

    this._blurMaterial = _getBlurShader(MAX_SAMPLES)
    this._equirectShader = null
    this._cubemapShader = null

    this._compileMaterial(this._blurMaterial)
  }

  /**
   * Generates a PMREM from a supplied Scene, which can be faster than using an
   * image if networking bandwidth is low. Optional sigma specifies a blur radius
   * in radians to be applied to the scene before PMREM generation. Optional near
   * and far planes ensure the scene is rendered in its entirety (the cubeCamera
   * is placed at the origin).
   */
  fromScene(scene, sigma = 0, near = 0.1, far = 100) {
    _oldTarget = this._renderer.getRenderTarget()
    const cubeUVRenderTarget = this._allocateTargets()

    this._sceneToCubeUV(scene, near, far, cubeUVRenderTarget)
    if (sigma > 0) {
      this._blur(cubeUVRenderTarget, 0, 0, sigma)
    }

    this._applyPMREM(cubeUVRenderTarget)
    this._cleanup(cubeUVRenderTarget)

    return cubeUVRenderTarget
  }

  /**
   * Generates a PMREM from an equirectangular texture, which can be either LDR
   * (RGBFormat) or HDR (RGBEFormat). The ideal input image size is 1k (1024 x 512),
   * as this matches best with the 256 x 256 cubemap output.
   */
  fromEquirectangular(equirectangular) {
    return this._fromTexture(equirectangular)
  }

  /**
   * Generates a PMREM from an cubemap texture, which can be either LDR
   * (RGBFormat) or HDR (RGBEFormat). The ideal input cube size is 256 x 256,
   * as this matches best with the 256 x 256 cubemap output.
   */
  fromCubemap(cubemap) {
    return this._fromTexture(cubemap)
  }

  /**
   * Pre-compiles the cubemap shader. You can get faster start-up by invoking this method during
   * your texture's network fetch for increased concurrency.
   */
  compileCubemapShader() {
    if (this._cubemapShader === null) {
      this._cubemapShader = _getCubemapShader()
      this._compileMaterial(this._cubemapShader)
    }
  }

  /**
   * Pre-compiles the equirectangular shader. You can get faster start-up by invoking this method during
   * your texture's network fetch for increased concurrency.
   */
  compileEquirectangularShader() {
    if (this._equirectShader === null) {
      this._equirectShader = _getEquirectShader()
      this._compileMaterial(this._equirectShader)
    }
  }

  /**
   * Disposes of the PMREMGenerator's internal memory. Note that PMREMGenerator is a static class,
   * so you should not need more than one PMREMGenerator object. If you do, calling dispose() on
   * one of them will cause any others to also become unusable.
   */
  dispose() {
    this._blurMaterial.dispose()

    if (this._cubemapShader !== null) this._cubemapShader.dispose()
    if (this._equirectShader !== null) this._equirectShader.dispose()

    for (let i = 0; i < _lodPlanes.length; i++) {
      _lodPlanes[i].dispose()
    }
  }

  // private interface

  _cleanup(outputTarget) {
    this._pingPongRenderTarget.dispose()
    this._renderer.setRenderTarget(_oldTarget)
    outputTarget.scissorTest = false
    _setViewport(outputTarget, 0, 0, outputTarget.width, outputTarget.height)
  }

  _fromTexture(texture) {
    _oldTarget = this._renderer.getRenderTarget()
    const cubeUVRenderTarget = this._allocateTargets(texture)
    this._textureToCubeUV(texture, cubeUVRenderTarget)
    this._applyPMREM(cubeUVRenderTarget)
    this._cleanup(cubeUVRenderTarget)

    return cubeUVRenderTarget
  }

  _allocateTargets(texture) {
    // warning: null texture is valid

    const params = {
      magFilter: NearestFilter,
      minFilter: NearestFilter,
      generateMipmaps: false,
      type: UnsignedByteType,
      format: RGBEFormat,
      encoding: _isLDR(texture) ? texture.encoding : RGBEEncoding,
      depthBuffer: false,
    }

    const cubeUVRenderTarget = _createRenderTarget(params)
    cubeUVRenderTarget.depthBuffer = texture ? false : true
    this._pingPongRenderTarget = _createRenderTarget(params)
    return cubeUVRenderTarget
  }

  _compileMaterial(material) {
    const tmpMesh = new Mesh(_lodPlanes[0], material)
    this._renderer.compile(tmpMesh, _flatCamera)
  }

  _sceneToCubeUV(scene, near, far, cubeUVRenderTarget) {
    const fov = 90
    const aspect = 1
    const cubeCamera = new PerspectiveCamera(fov, aspect, near, far)
    const upSign = [1, -1, 1, 1, 1, 1]
    const forwardSign = [1, 1, 1, -1, -1, -1]
    const renderer = this._renderer

    const outputEncoding = renderer.outputEncoding
    const toneMapping = renderer.toneMapping
    const clearColor = renderer.getClearColor()
    const clearAlpha = renderer.getClearAlpha()

    renderer.toneMapping = NoToneMapping
    renderer.outputEncoding = LinearEncoding

    let background = scene.background
    if (background && background.isColor) {
      background.convertSRGBToLinear()
      // Convert linear to RGBE
      const maxComponent = Math.max(background.r, background.g, background.b)
      const fExp = Math.min(Math.max(Math.ceil(Math.log2(maxComponent)), -128.0), 127.0)
      background = background.multiplyScalar(Math.pow(2.0, -fExp))
      const alpha = (fExp + 128.0) / 255.0
      renderer.setClearColor(background, alpha)
      scene.background = null
    }

    for (let i = 0; i < 6; i++) {
      const col = i % 3
      if (col == 0) {
        cubeCamera.up.set(0, upSign[i], 0)
        cubeCamera.lookAt(forwardSign[i], 0, 0)
      } else if (col == 1) {
        cubeCamera.up.set(0, 0, upSign[i])
        cubeCamera.lookAt(0, forwardSign[i], 0)
      } else {
        cubeCamera.up.set(0, upSign[i], 0)
        cubeCamera.lookAt(0, 0, forwardSign[i])
      }

      _setViewport(cubeUVRenderTarget, col * SIZE_MAX, i > 2 ? SIZE_MAX : 0, SIZE_MAX, SIZE_MAX)
      renderer.setRenderTarget(cubeUVRenderTarget)
      renderer.render(scene, cubeCamera)
    }

    renderer.toneMapping = toneMapping
    renderer.outputEncoding = outputEncoding
    renderer.setClearColor(clearColor, clearAlpha)
  }

  _textureToCubeUV(texture, cubeUVRenderTarget) {
    const renderer = this._renderer

    if (texture.isCubeTexture) {
      if (this._cubemapShader == null) {
        this._cubemapShader = _getCubemapShader()
      }
    } else {
      if (this._equirectShader == null) {
        this._equirectShader = _getEquirectShader()
      }
    }

    const material = texture.isCubeTexture ? this._cubemapShader : this._equirectShader
    const mesh = new Mesh(_lodPlanes[0], material)

    const uniforms = material.uniforms

    uniforms['envMap'].value = texture

    if (!texture.isCubeTexture) {
      uniforms['texelSize'].value.set(1.0 / texture.image.width, 1.0 / texture.image.height)
    }

    uniforms['inputEncoding'].value = ENCODINGS[texture.encoding]
    uniforms['outputEncoding'].value = ENCODINGS[cubeUVRenderTarget.texture.encoding]

    _setViewport(cubeUVRenderTarget, 0, 0, 3 * SIZE_MAX, 2 * SIZE_MAX)

    renderer.setRenderTarget(cubeUVRenderTarget)
    renderer.render(mesh, _flatCamera)
  }

  _applyPMREM(cubeUVRenderTarget) {
    const renderer = this._renderer
    const autoClear = renderer.autoClear
    renderer.autoClear = false

    for (let i = 1; i < TOTAL_LODS; i++) {
      const sigma = Math.sqrt(_sigmas[i] * _sigmas[i] - _sigmas[i - 1] * _sigmas[i - 1])

      const poleAxis = _axisDirections[(i - 1) % _axisDirections.length]

      this._blur(cubeUVRenderTarget, i - 1, i, sigma, poleAxis)
    }

    renderer.autoClear = autoClear
  }

  /**
   * This is a two-pass Gaussian blur for a cubemap. Normally this is done
   * vertically and horizontally, but this breaks down on a cube. Here we apply
   * the blur latitudinally (around the poles), and then longitudinally (towards
   * the poles) to approximate the orthogonally-separable blur. It is least
   * accurate at the poles, but still does a decent job.
   */
  _blur(cubeUVRenderTarget, lodIn, lodOut, sigma, poleAxis) {
    const pingPongRenderTarget = this._pingPongRenderTarget

    this._halfBlur(cubeUVRenderTarget, pingPongRenderTarget, lodIn, lodOut, sigma, 'latitudinal', poleAxis)

    this._halfBlur(pingPongRenderTarget, cubeUVRenderTarget, lodOut, lodOut, sigma, 'longitudinal', poleAxis)
  }

  _halfBlur(targetIn, targetOut, lodIn, lodOut, sigmaRadians, direction, poleAxis) {
    const renderer = this._renderer
    const blurMaterial = this._blurMaterial

    if (direction !== 'latitudinal' && direction !== 'longitudinal') {
      console.error('blur direction must be either latitudinal or longitudinal!')
    }

    // Number of standard deviations at which to cut off the discrete approximation.
    const STANDARD_DEVIATIONS = 3

    const blurMesh = new Mesh(_lodPlanes[lodOut], blurMaterial)
    const blurUniforms = blurMaterial.uniforms

    const pixels = _sizeLods[lodIn] - 1
    const radiansPerPixel = isFinite(sigmaRadians) ? Math.PI / (2 * pixels) : (2 * Math.PI) / (2 * MAX_SAMPLES - 1)
    const sigmaPixels = sigmaRadians / radiansPerPixel
    const samples = isFinite(sigmaRadians) ? 1 + Math.floor(STANDARD_DEVIATIONS * sigmaPixels) : MAX_SAMPLES

    if (samples > MAX_SAMPLES) {
      console.warn(`sigmaRadians, ${sigmaRadians}, is too large and will clip, as it requested ${samples} samples when the maximum is set to ${MAX_SAMPLES}`)
    }

    const weights = []
    let sum = 0

    for (let i = 0; i < MAX_SAMPLES; ++i) {
      const x = i / sigmaPixels
      const weight = Math.exp((-x * x) / 2)
      weights.push(weight)

      if (i == 0) {
        sum += weight
      } else if (i < samples) {
        sum += 2 * weight
      }
    }

    for (let i = 0; i < weights.length; i++) {
      weights[i] = weights[i] / sum
    }

    blurUniforms['envMap'].value = targetIn.texture
    blurUniforms['samples'].value = samples
    blurUniforms['weights'].value = weights
    blurUniforms['latitudinal'].value = direction === 'latitudinal'

    if (poleAxis) {
      blurUniforms['poleAxis'].value = poleAxis
    }

    blurUniforms['dTheta'].value = radiansPerPixel
    blurUniforms['mipInt'].value = LOD_MAX - lodIn
    blurUniforms['inputEncoding'].value = ENCODINGS[targetIn.texture.encoding]
    blurUniforms['outputEncoding'].value = ENCODINGS[targetIn.texture.encoding]

    const outputSize = _sizeLods[lodOut]
    const x = 3 * Math.max(0, SIZE_MAX - 2 * outputSize)
    const y = (lodOut === 0 ? 0 : 2 * SIZE_MAX) + 2 * outputSize * (lodOut > LOD_MAX - LOD_MIN ? lodOut - LOD_MAX + LOD_MIN : 0)

    _setViewport(targetOut, x, y, 3 * outputSize, 2 * outputSize)
    renderer.setRenderTarget(targetOut)
    renderer.render(blurMesh, _flatCamera)
  }
}

function _isLDR(texture) {
  if (texture === undefined || texture.type !== UnsignedByteType) return false

  return texture.encoding === LinearEncoding || texture.encoding === sRGBEncoding || texture.encoding === GammaEncoding
}

function _createPlanes() {
  const _lodPlanes = []
  const _sizeLods = []
  const _sigmas = []

  let lod = LOD_MAX

  for (let i = 0; i < TOTAL_LODS; i++) {
    const sizeLod = Math.pow(2, lod)
    _sizeLods.push(sizeLod)
    let sigma = 1.0 / sizeLod

    if (i > LOD_MAX - LOD_MIN) {
      sigma = EXTRA_LOD_SIGMA[i - LOD_MAX + LOD_MIN - 1]
    } else if (i == 0) {
      sigma = 0
    }

    _sigmas.push(sigma)

    const texelSize = 1.0 / (sizeLod - 1)
    const min = -texelSize / 2
    const max = 1 + texelSize / 2
    const uv1 = [min, min, max, min, max, max, min, min, max, max, min, max]

    const cubeFaces = 6
    const vertices = 6
    const positionSize = 3
    const uvSize = 2
    const faceIndexSize = 1

    const position = new Float32Array(positionSize * vertices * cubeFaces)
    const uv = new Float32Array(uvSize * vertices * cubeFaces)
    const faceIndex = new Float32Array(faceIndexSize * vertices * cubeFaces)

    for (let face = 0; face < cubeFaces; face++) {
      const x = ((face % 3) * 2) / 3 - 1
      const y = face > 2 ? 0 : -1
      const coordinates = [x, y, 0, x + 2 / 3, y, 0, x + 2 / 3, y + 1, 0, x, y, 0, x + 2 / 3, y + 1, 0, x, y + 1, 0]
      position.set(coordinates, positionSize * vertices * face)
      uv.set(uv1, uvSize * vertices * face)
      const fill = [face, face, face, face, face, face]
      faceIndex.set(fill, faceIndexSize * vertices * face)
    }

    const planes = new BufferGeometry()
    planes.setAttribute('position', new BufferAttribute(position, positionSize))
    planes.setAttribute('uv', new BufferAttribute(uv, uvSize))
    planes.setAttribute('faceIndex', new BufferAttribute(faceIndex, faceIndexSize))
    _lodPlanes.push(planes)

    if (lod > LOD_MIN) {
      lod--
    }
  }

  return {_lodPlanes, _sizeLods, _sigmas}
}

function _createRenderTarget(params) {
  const cubeUVRenderTarget = new WebGLRenderTarget(3 * SIZE_MAX, 3 * SIZE_MAX, params)
  cubeUVRenderTarget.texture.mapping = CubeUVReflectionMapping
  cubeUVRenderTarget.texture.name = 'PMREM.cubeUv'
  cubeUVRenderTarget.scissorTest = true
  return cubeUVRenderTarget
}

function _setViewport(target, x, y, width, height) {
  target.viewport.set(x, y, width, height)
  target.scissor.set(x, y, width, height)
}

function _getBlurShader(maxSamples) {
  const weights = new Float32Array(maxSamples)
  const poleAxis = new Vector3(0, 1, 0)
  const shaderMaterial = new RawShaderMaterial({
    name: 'SphericalGaussianBlur',

    defines: {n: maxSamples},

    uniforms: {
      envMap: {value: null},
      samples: {value: 1},
      weights: {value: weights},
      latitudinal: {value: false},
      dTheta: {value: 0},
      mipInt: {value: 0},
      poleAxis: {value: poleAxis},
      inputEncoding: {value: ENCODINGS[LinearEncoding]},
      outputEncoding: {value: ENCODINGS[LinearEncoding]},
    },

    vertexShader: _getCommonVertexShader(),

    fragmentShader: /* glsl */ `

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform int samples;
			uniform float weights[ n ];
			uniform bool latitudinal;
			uniform float dTheta;
			uniform float mipInt;
			uniform vec3 poleAxis;

			${_getEncodings()}

			#define ENVMAP_TYPE_CUBE_UV
			#include <cube_uv_reflection_fragment>

			vec3 getSample( float theta, vec3 axis ) {

				float cosTheta = cos( theta );
				// Rodrigues' axis-angle rotation
				vec3 sampleDirection = vOutputDirection * cosTheta
					+ cross( axis, vOutputDirection ) * sin( theta )
					+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );

				return bilinearCubeUV( envMap, sampleDirection, mipInt );

			}

			void main() {

				vec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );

				if ( all( equal( axis, vec3( 0.0 ) ) ) ) {

					axis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );

				}

				axis = normalize( axis );

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
				gl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );

				for ( int i = 1; i < n; i++ ) {

					if ( i >= samples ) {

						break;

					}

					float theta = dTheta * float( i );
					gl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );
					gl_FragColor.rgb += weights[ i ] * getSample( theta, axis );

				}

				gl_FragColor = linearToOutputTexel( gl_FragColor );

			}
		`,

    blending: NoBlending,
    depthTest: false,
    depthWrite: false,
  })

  return shaderMaterial
}

function _getEquirectShader() {
  const texelSize = new Vector2(1, 1)
  const shaderMaterial = new RawShaderMaterial({
    name: 'EquirectangularToCubeUV',

    uniforms: {
      envMap: {value: null},
      texelSize: {value: texelSize},
      inputEncoding: {value: ENCODINGS[LinearEncoding]},
      outputEncoding: {value: ENCODINGS[LinearEncoding]},
    },

    vertexShader: _getCommonVertexShader(),

    fragmentShader: /* glsl */ `

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform vec2 texelSize;

			${_getEncodings()}

			#include <common>

			void main() {

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );

				vec3 outputDirection = normalize( vOutputDirection );
				vec2 uv = equirectUv( outputDirection );

				vec2 f = fract( uv / texelSize - 0.5 );
				uv -= f * texelSize;
				vec3 tl = envMapTexelToLinear( texture2D ( envMap, uv ) ).rgb;
				uv.x += texelSize.x;
				vec3 tr = envMapTexelToLinear( texture2D ( envMap, uv ) ).rgb;
				uv.y += texelSize.y;
				vec3 br = envMapTexelToLinear( texture2D ( envMap, uv ) ).rgb;
				uv.x -= texelSize.x;
				vec3 bl = envMapTexelToLinear( texture2D ( envMap, uv ) ).rgb;

				vec3 tm = mix( tl, tr, f.x );
				vec3 bm = mix( bl, br, f.x );
				gl_FragColor.rgb = mix( tm, bm, f.y );

				gl_FragColor = linearToOutputTexel( gl_FragColor );

			}
		`,

    blending: NoBlending,
    depthTest: false,
    depthWrite: false,
  })

  return shaderMaterial
}

function _getCubemapShader() {
  const shaderMaterial = new RawShaderMaterial({
    name: 'CubemapToCubeUV',

    uniforms: {
      envMap: {value: null},
      inputEncoding: {value: ENCODINGS[LinearEncoding]},
      outputEncoding: {value: ENCODINGS[LinearEncoding]},
    },

    vertexShader: _getCommonVertexShader(),

    fragmentShader: /* glsl */ `

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform samplerCube envMap;

			${_getEncodings()}

			void main() {

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
				gl_FragColor.rgb = envMapTexelToLinear( textureCube( envMap, vec3( - vOutputDirection.x, vOutputDirection.yz ) ) ).rgb;
				gl_FragColor = linearToOutputTexel( gl_FragColor );

			}
		`,

    blending: NoBlending,
    depthTest: false,
    depthWrite: false,
  })

  return shaderMaterial
}

function _getCommonVertexShader() {
  return /* glsl */ `

		precision mediump float;
		precision mediump int;

		attribute vec3 position;
		attribute vec2 uv;
		attribute float faceIndex;

		varying vec3 vOutputDirection;

		// RH coordinate system; PMREM face-indexing convention
		vec3 getDirection( vec2 uv, float face ) {

			uv = 2.0 * uv - 1.0;

			vec3 direction = vec3( uv, 1.0 );

			if ( face == 0.0 ) {

				direction = direction.zyx; // ( 1, v, u ) pos x

			} else if ( face == 1.0 ) {

				direction = direction.xzy;
				direction.xz *= -1.0; // ( -u, 1, -v ) pos y

			} else if ( face == 2.0 ) {

				direction.x *= -1.0; // ( -u, v, 1 ) pos z

			} else if ( face == 3.0 ) {

				direction = direction.zyx;
				direction.xz *= -1.0; // ( -1, v, -u ) neg x

			} else if ( face == 4.0 ) {

				direction = direction.xzy;
				direction.xy *= -1.0; // ( -u, -1, v ) neg y

			} else if ( face == 5.0 ) {

				direction.z *= -1.0; // ( u, v, -1 ) neg z

			}

			return direction;

		}

		void main() {

			vOutputDirection = getDirection( uv, faceIndex );
			gl_Position = vec4( position, 1.0 );

		}
	`
}

function _getEncodings() {
  return /* glsl */ `

		uniform int inputEncoding;
		uniform int outputEncoding;

		#include <encodings_pars_fragment>

		vec4 inputTexelToLinear( vec4 value ) {

			if ( inputEncoding == 0 ) {

				return value;

			} else if ( inputEncoding == 1 ) {

				return sRGBToLinear( value );

			} else if ( inputEncoding == 2 ) {

				return RGBEToLinear( value );

			} else if ( inputEncoding == 3 ) {

				return RGBMToLinear( value, 7.0 );

			} else if ( inputEncoding == 4 ) {

				return RGBMToLinear( value, 16.0 );

			} else if ( inputEncoding == 5 ) {

				return RGBDToLinear( value, 256.0 );

			} else {

				return GammaToLinear( value, 2.2 );

			}

		}

		vec4 linearToOutputTexel( vec4 value ) {

			if ( outputEncoding == 0 ) {

				return value;

			} else if ( outputEncoding == 1 ) {

				return LinearTosRGB( value );

			} else if ( outputEncoding == 2 ) {

				return LinearToRGBE( value );

			} else if ( outputEncoding == 3 ) {

				return LinearToRGBM( value, 7.0 );

			} else if ( outputEncoding == 4 ) {

				return LinearToRGBM( value, 16.0 );

			} else if ( outputEncoding == 5 ) {

				return LinearToRGBD( value, 256.0 );

			} else {

				return LinearToGamma( value, 2.2 );

			}

		}

		vec4 envMapTexelToLinear( vec4 color ) {

			return inputTexelToLinear( color );

		}
	`
}

export {PMREMGenerator}
